{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:30:54.688309Z",
     "start_time": "2025-02-26T08:30:51.414030Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 2.0.2\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.1\n",
      "torch 2.6.0+cu126\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 加载数据"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:30:56.780325Z",
     "start_time": "2025-02-26T08:30:54.689310Z"
    }
   },
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# fashion_mnist图像分类数据集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# torchvision 数据集里没有提供训练集和验证集的划分\n",
    "# 当然也可以用 torch.utils.data.Dataset 实现人为划分\n",
    "# 从数据集到dataloader\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=16, shuffle=True)\n",
    "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=16, shuffle=False)"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:31:02.836911Z",
     "start_time": "2025-02-26T08:30:56.780325Z"
    }
   },
   "source": [
    "from torchvision.transforms import Normalize\n",
    "\n",
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "def cal_mean_std(ds):\n",
    "    mean = 0.\n",
    "    std = 0.\n",
    "    for img, _ in ds:\n",
    "        mean += img.mean(dim=(1, 2))\n",
    "        std += img.std(dim=(1, 2))\n",
    "    mean /= len(ds)\n",
    "    std /= len(ds)\n",
    "    return mean, std\n",
    "\n",
    "\n",
    "print(cal_mean_std(train_ds))\n",
    "# 0.2860， 0.3205\n",
    "transforms = nn.Sequential(\n",
    "    Normalize([0.2860], [0.3205])\n",
    ")\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([0.2860]), tensor([0.3205]))\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义模型\n",
    "\n",
    "这里我们没有用`nn.Linear`的默认初始化，而是采用了xavier均匀分布去初始化全连接层的权重\n",
    "\n",
    "xavier初始化出自论文 《Understanding the difficulty of training deep feedforward neural networks》，适用于使用`tanh`和`sigmoid`激活函数的方法。当然，我们这里的模型采用的是`relu`激活函数，采用He初始化（何凯明初始化）会更加合适。感兴趣的同学可以自己动手修改并比对效果。\n",
    "\n",
    "|神经网络层数|初始化方式|early stop at epoch| val_loss | vla_acc|\n",
    "|-|-|-|-|-|\n",
    "|20|默认|\n",
    "|20|xaviier_uniform|\n",
    "|20|he_uniform|\n",
    "|...|\n",
    "\n",
    "He初始化出自论文 《Delving deep into rectifiers: Surpassing human-level performance on ImageNet classification》"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:31:02.847039Z",
     "start_time": "2025-02-26T08:31:02.837912Z"
    }
   },
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self, layers_num=2):\n",
    "        super().__init__()\n",
    "        self.transforms = transforms\n",
    "        self.flatten = nn.Flatten()\n",
    "        # 多加几层\n",
    "        self.linear_relu_stack = nn.Sequential(\n",
    "            nn.Linear(28 * 28, 100),  # in_features=784, out_features=300\n",
    "            nn.SELU(),\n",
    "        )\n",
    "        # 加19层\n",
    "        for i in range(1, layers_num):\n",
    "            self.linear_relu_stack.add_module(f\"Linear_{i}\", nn.Linear(100, 100))\n",
    "            self.linear_relu_stack.add_module(f\"selu\", nn.SELU()) # 这里采用SELU激活函数\n",
    "        # 输出层\n",
    "        self.linear_relu_stack.add_module(\"Output Layer\", nn.Linear(100, 10))\n",
    "        \n",
    "        # 初始化权重\n",
    "        self.init_weights()\n",
    "        \n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层的权重 W\"\"\"\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, nn.Linear):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # x.shape [batch size, 1, 28, 28]\n",
    "        x = self.transforms(x)\n",
    "        x = self.flatten(x)  \n",
    "        # 展平后 x.shape [batch size, 28 * 28]\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        # logits.shape [batch size, 10]\n",
    "        return logits\n",
    "\n",
    "for idx, (key, value) in enumerate(NeuralNetwork(20).named_parameters()):\n",
    "    print(f\"Linear_{idx // 2:>02}\\tparamerters num: {np.prod(value.shape)}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Linear_00\tparamerters num: 78400\n",
      "Linear_00\tparamerters num: 100\n",
      "Linear_01\tparamerters num: 10000\n",
      "Linear_01\tparamerters num: 100\n",
      "Linear_02\tparamerters num: 10000\n",
      "Linear_02\tparamerters num: 100\n",
      "Linear_03\tparamerters num: 10000\n",
      "Linear_03\tparamerters num: 100\n",
      "Linear_04\tparamerters num: 10000\n",
      "Linear_04\tparamerters num: 100\n",
      "Linear_05\tparamerters num: 10000\n",
      "Linear_05\tparamerters num: 100\n",
      "Linear_06\tparamerters num: 10000\n",
      "Linear_06\tparamerters num: 100\n",
      "Linear_07\tparamerters num: 10000\n",
      "Linear_07\tparamerters num: 100\n",
      "Linear_08\tparamerters num: 10000\n",
      "Linear_08\tparamerters num: 100\n",
      "Linear_09\tparamerters num: 10000\n",
      "Linear_09\tparamerters num: 100\n",
      "Linear_10\tparamerters num: 10000\n",
      "Linear_10\tparamerters num: 100\n",
      "Linear_11\tparamerters num: 10000\n",
      "Linear_11\tparamerters num: 100\n",
      "Linear_12\tparamerters num: 10000\n",
      "Linear_12\tparamerters num: 100\n",
      "Linear_13\tparamerters num: 10000\n",
      "Linear_13\tparamerters num: 100\n",
      "Linear_14\tparamerters num: 10000\n",
      "Linear_14\tparamerters num: 100\n",
      "Linear_15\tparamerters num: 10000\n",
      "Linear_15\tparamerters num: 100\n",
      "Linear_16\tparamerters num: 10000\n",
      "Linear_16\tparamerters num: 100\n",
      "Linear_17\tparamerters num: 10000\n",
      "Linear_17\tparamerters num: 100\n",
      "Linear_18\tparamerters num: 10000\n",
      "Linear_18\tparamerters num: 100\n",
      "Linear_19\tparamerters num: 10000\n",
      "Linear_19\tparamerters num: 100\n",
      "Linear_20\tparamerters num: 1000\n",
      "Linear_20\tparamerters num: 10\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:31:02.900138Z",
     "start_time": "2025-02-26T08:31:02.848030Z"
    }
   },
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        \n",
    "        preds = logits.argmax(axis=-1)    # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "outputs": [],
   "execution_count": 5
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:31:06.086500Z",
     "start_time": "2025-02-26T08:31:02.900138Z"
    }
   },
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ],
   "outputs": [],
   "execution_count": 6
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:31:06.091912Z",
     "start_time": "2025-02-26T08:31:06.087497Z"
    }
   },
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "outputs": [],
   "execution_count": 7
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:31:06.112532Z",
     "start_time": "2025-02-26T08:31:06.091912Z"
    }
   },
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "outputs": [],
   "execution_count": 8
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:44:03.312151Z",
     "start_time": "2025-02-26T08:31:06.113534Z"
    }
   },
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                    \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 100\n",
    "\n",
    "model = NeuralNetwork(layers_num=10)\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用SGD\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/selu\")\n",
    "tensorboard_callback.draw_model(model, [1, 28, 28])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints/selu\"):\n",
    "    #创建多级目录\n",
    "    os.makedirs(\"checkpoints/selu\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/selu\", save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10, min_delta=0.001)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_loader)\n",
    "    )"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/375000 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "0c4de959704c46608b4c2546f1cf6031"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 32 / global_step 120000\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:45:59.583157Z",
     "start_time": "2025-02-26T08:45:59.390465Z"
    }
   },
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(6 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=10000)  #横坐标是 steps"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 12
  },
  {
   "cell_type": "markdown",
   "source": [
    "## selu激活函数，可以加速收敛，效果相对于relu更好"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-26T08:46:06.537047Z",
     "start_time": "2025-02-26T08:46:04.460107Z"
    }
   },
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/selu/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, val_loader, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.4047\n",
      "accuracy: 0.8824\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": ""
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
